package com.clouddms.service.auth;

import com.clouddms.dto.LoginRequest;
import com.clouddms.dto.LoginResponse;
import com.clouddms.dto.RegisterRequest;
import com.clouddms.entity.Admin;
import com.clouddms.entity.User;
import com.clouddms.entity.UserOperationLog;
import com.clouddms.repository.AdminRepository;
import com.clouddms.repository.UserRepository;
import com.clouddms.service.common.IService;
import com.clouddms.service.common.LogService;
import com.clouddms.service.common.ServiceStatus;
import com.clouddms.util.JwtUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.Map;
import java.util.HashMap;
import java.util.UUID;
import java.util.ArrayList;
import java.util.stream.Collectors;

/**
 * 用户服务业务逻辑层
 * 负责用户认证、注册、管理等业务逻辑
 */
@Service
public class UserService implements IService {

    private static final Logger logger = LoggerFactory.getLogger(UserService.class);

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private AdminRepository adminRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Autowired
    private JwtUtil jwtUtil;

    @Autowired
    private TokenBlacklistService tokenBlacklistService;

    @Autowired
    private LogService logService;

    @Value("${clouddms.jwt.expiration:86400000}") // 24小时
    private Long jwtExpiration;

    /**
     * 用户登录
     * @param loginRequest 登录请求
     * @return 登录响应
     */
    @Transactional
    public LoginResponse login(LoginRequest loginRequest) {
        try {
            logger.info("用户登录尝试: {}, 类型: {}", loginRequest.getUsername(), loginRequest.getUserType());

            if ("ADMIN".equals(loginRequest.getUserType())) {
                return adminLogin(loginRequest);
            } else {
                return userLogin(loginRequest);
            }
        } catch (Exception e) {
            logger.error("登录过程中发生错误: {}", e.getMessage(), e);
            return LoginResponse.failure("登录失败，请稍后重试");
        }
    }

    /**
     * 普通用户登录
     */
    private LoginResponse userLogin(LoginRequest loginRequest) {
        Optional<User> userOpt = userRepository.findByUsername(loginRequest.getUsername());
        
        if (!userOpt.isPresent()) {
            logger.warn("用户登录失败 - 用户不存在: {}", loginRequest.getUsername());
            return LoginResponse.failure("用户名或密码错误");
        }

        User user = userOpt.get();
        
        // 检查用户是否活跃
        if (!user.getIsActive()) {
            logger.warn("用户登录失败 - 账户已禁用: {}", loginRequest.getUsername());
            return LoginResponse.failure("账户已被禁用，请联系管理员");
        }

        // 验证密码
        if (!passwordEncoder.matches(loginRequest.getPassword(), user.getPassword())) {
            logger.warn("用户登录失败 - 密码错误: {}", loginRequest.getUsername());
            return LoginResponse.failure("用户名或密码错误");
        }

        // 准备角色信息
        Set<String> roles = new HashSet<>();
        if (user.getRoles() != null) {
            user.getRoles().forEach(role -> roles.add(role.name()));
        } else {
            roles.add("USER");
        }

        // 撤销该用户的旧Token
        tokenBlacklistService.revokeUserTokens(user.getUserId());
        
        // 生成JWT Token
        String token = jwtUtil.generateToken(user.getUsername(), user.getUserId(), roles);
        
        // 记录新Token
        String tokenId = jwtUtil.getTokenIdFromToken(token);
        tokenBlacklistService.recordUserToken(user.getUserId(), tokenId);
        
        logger.info("用户登录成功: {}", loginRequest.getUsername());
        return LoginResponse.success(token, user.getUserId(), user.getUsername(), roles, jwtExpiration / 1000);
    }

    /**
     * 管理员登录
     */
    private LoginResponse adminLogin(LoginRequest loginRequest) {
        Optional<Admin> adminOpt = adminRepository.findByUsername(loginRequest.getUsername());
        
        if (!adminOpt.isPresent()) {
            logger.warn("管理员登录失败 - 管理员不存在: {}", loginRequest.getUsername());
            return LoginResponse.failure("用户名或密码错误");
        }

        Admin admin = adminOpt.get();
        
        // 验证密码
        if (!passwordEncoder.matches(loginRequest.getPassword(), admin.getPassword())) {
            logger.warn("管理员登录失败 - 密码错误: {}", loginRequest.getUsername());
            return LoginResponse.failure("用户名或密码错误");
        }

        // 管理员角色
        Set<String> roles = new HashSet<>();
        roles.add("ADMIN");

        // 撤销该管理员的旧Token
        tokenBlacklistService.revokeUserTokens(admin.getAdminId());
        
        // 生成JWT Token
        String token = jwtUtil.generateToken(admin.getUsername(), admin.getAdminId(), roles);
        
        // 记录新Token
        String tokenId = jwtUtil.getTokenIdFromToken(token);
        tokenBlacklistService.recordUserToken(admin.getAdminId(), tokenId);
        
        logger.info("管理员登录成功: {}", loginRequest.getUsername());
        return LoginResponse.success(token, admin.getAdminId(), admin.getUsername(), roles, jwtExpiration / 1000);
    }

    /**
     * 用户注册
     * @param registerRequest 注册请求
     * @return 注册结果
     */
    @Transactional
    public LoginResponse register(RegisterRequest registerRequest) {
        try {
            logger.info("用户注册尝试: {}", registerRequest.getUsername());

            // 验证密码匹配
            if (!registerRequest.isPasswordsMatch()) {
                return LoginResponse.failure("两次输入的密码不一致");
            }

            // 检查用户名是否已存在
            if (userRepository.existsByUsername(registerRequest.getUsername())) {
                logger.warn("用户注册失败 - 用户名已存在: {}", registerRequest.getUsername());
                return LoginResponse.failure("用户名已存在");
            }

            // 检查邮箱是否已存在
            if (registerRequest.getEmail() != null && 
                userRepository.existsByEmail(registerRequest.getEmail())) {
                logger.warn("用户注册失败 - 邮箱已存在: {}", registerRequest.getEmail());
                return LoginResponse.failure("邮箱已被注册");
            }

            // 创建用户
            User user = new User();
            user.setUsername(registerRequest.getUsername());
            user.setPassword(passwordEncoder.encode(registerRequest.getPassword()));
            user.setEmail(registerRequest.getEmail());
            user.setIsActive(true);
            
            // 设置默认角色
            Set<User.UserRole> roles = new HashSet<>();
            roles.add(User.UserRole.USER);
            user.setRoles(roles);

            // 保存用户
            user = userRepository.save(user);

            logger.info("用户注册成功: {}", registerRequest.getUsername());

            // 自动登录
            Set<String> roleStrings = new HashSet<>();
            roleStrings.add("USER");
            String token = jwtUtil.generateToken(user.getUsername(), user.getUserId(), roleStrings);
            
            // 记录新Token
            String tokenId = jwtUtil.getTokenIdFromToken(token);
            tokenBlacklistService.recordUserToken(user.getUserId(), tokenId);
            
            return LoginResponse.success(token, user.getUserId(), user.getUsername(), roleStrings, jwtExpiration / 1000);

        } catch (Exception e) {
            logger.error("注册过程中发生错误: {}", e.getMessage(), e);
            return LoginResponse.failure("注册失败，请稍后重试");
        }
    }

    /**
     * 根据用户ID查找用户
     * @param userId 用户ID
     * @return 用户对象
     */
    public Optional<User> findById(Long userId) {
        return userRepository.findById(userId);
    }

    /**
     * 根据用户名查找用户
     * @param username 用户名
     * @return 用户对象
     */
    public Optional<User> findByUsername(String username) {
        return userRepository.findByUsername(username);
    }

    /**
     * 获取所有用户列表（管理员功能）
     * @return 用户列表
     */
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    /**
     * 获取活跃用户列表
     * @return 活跃用户列表
     */
    public List<User> getActiveUsers() {
        return userRepository.findByIsActive(true);
    }

    /**
     * 禁用用户（管理员功能）
     * @param userId 用户ID
     * @return 操作结果
     */
    @Transactional
    public boolean disableUser(Long userId) {
        try {
            Optional<User> userOpt = userRepository.findById(userId);
            if (userOpt.isPresent()) {
                User user = userOpt.get();
                user.setIsActive(false);
                userRepository.save(user);
                logger.info("用户已被禁用: {}", user.getUsername());
                return true;
            }
            return false;
        } catch (Exception e) {
            logger.error("禁用用户时发生错误: {}", e.getMessage(), e);
            return false;
        }
    }

    /**
     * 启用用户（管理员功能）
     * @param userId 用户ID
     * @return 操作结果
     */
    @Transactional
    public boolean enableUser(Long userId) {
        try {
            Optional<User> userOpt = userRepository.findById(userId);
            if (userOpt.isPresent()) {
                User user = userOpt.get();
                user.setIsActive(true);
                userRepository.save(user);
                logger.info("用户已被启用: {}", user.getUsername());
                return true;
            }
            return false;
        } catch (Exception e) {
            logger.error("启用用户时发生错误: {}", e.getMessage(), e);
            return false;
        }
    }

    /**
     * 统计用户数量
     * @return 用户统计信息
     */
    public UserStats getUserStats() {
        long totalUsers = userRepository.count();
        long activeUsers = userRepository.countActiveUsers();
        return new UserStats(totalUsers, activeUsers, totalUsers - activeUsers);
    }

    // IService 接口实现
    @Override
    public String getServiceName() {
        return "user-service";
    }

    @Override
    public String getDisplayName() {
        return "用户服务";
    }

    @Override
    public String getDescription() {
        return "负责用户认证、注册和管理的核心服务";
    }

    @Override
    public ServiceStatus getStatus() {
        try {
            // 检查数据库连接
            userRepository.count();
            return ServiceStatus.RUNNING;
        } catch (Exception e) {
            logger.error("用户服务状态检查失败: {}", e.getMessage());
            return ServiceStatus.DISABLED;
        }
    }

    @Override
    public HealthStatus getHealthStatus() {
        try {
            long userCount = userRepository.count();
            return new HealthStatus(true, "服务正常运行，用户总数: " + userCount);
        } catch (Exception e) {
            return new HealthStatus(false, "数据库连接异常: " + e.getMessage());
        }
    }

    @Override
    public int getPriority() {
        return 1; // 最高优先级
    }

    @Override
    public String getVersion() {
        return "1.0.0";
    }

    /**
     * 手动撤销Token
     * @param token JWT Token
     */
    public void revokeToken(String token) {
        try {
            String tokenId = jwtUtil.getTokenIdFromToken(token);
            Long userId = jwtUtil.getUserIdFromToken(token);
            
            tokenBlacklistService.revokeToken(tokenId, userId);
            
            logger.info("已手动撤销Token: {}", tokenId);
        } catch (Exception e) {
            logger.error("撤销Token失败: {}", e.getMessage());
        }
    }

    /**
     * 检查邮箱是否已存在
     * @param email 邮箱
     * @return 是否存在
     */
    public boolean existsByEmail(String email) {
        try {
            return userRepository.existsByEmail(email);
        } catch (Exception e) {
            logger.error("检查邮箱存在性时发生异常: {}", e.getMessage(), e);
            return true; // 发生异常时返回true，避免重复邮箱
        }
    }

    /**
     * 创建新用户 (AuthController使用)
     * @param username 用户名
     * @param password 密码
     * @param email 邮箱
     * @return 创建结果
     */
    @Transactional
    public boolean createUser(String username, String password, String email) {
        try {
            // 检查用户名是否已存在
            if (userRepository.existsByUsername(username)) {
                logger.warn("用户创建失败 - 用户名已存在: {}", username);
                return false;
            }

            // 检查邮箱是否已存在
            if (email != null && userRepository.existsByEmail(email)) {
                logger.warn("用户创建失败 - 邮箱已存在: {}", email);
                return false;
            }

            // 创建用户
            User user = new User();
            user.setUsername(username);
            user.setPassword(passwordEncoder.encode(password));
            user.setEmail(email);
            user.setIsActive(true);
            
            // 设置默认角色
            Set<User.UserRole> roles = new HashSet<>();
            roles.add(User.UserRole.USER);
            user.setRoles(roles);

            // 保存用户
            userRepository.save(user);

            logger.info("用户创建成功: {}", username);
            return true;

        } catch (Exception e) {
            logger.error("创建用户时发生错误: {}", e.getMessage(), e);
            return false;
        }
    }

    /**
     * 搜索用户
     * @param search 搜索关键词（用户名或邮箱）
     * @return 用户列表
     */
    public List<User> searchUsers(String search) {
        try {
            if (search == null || search.trim().isEmpty()) {
                return getAllUsers();
            }
            
            String searchTerm = search.trim();
            List<User> users = new ArrayList<>();
            
            // 按用户名搜索
            Optional<User> userByUsername = userRepository.findByUsername(searchTerm);
            if (userByUsername.isPresent()) {
                users.add(userByUsername.get());
            }
            
            // 按邮箱搜索
            Optional<User> userByEmail = userRepository.findByEmail(searchTerm);
            if (userByEmail.isPresent() && !users.contains(userByEmail.get())) {
                users.add(userByEmail.get());
            }
            
            // 如果没有精确匹配，尝试模糊匹配
            if (users.isEmpty()) {
                users = userRepository.findAll().stream()
                    .filter(user -> 
                        user.getUsername().toLowerCase().contains(searchTerm.toLowerCase()) ||
                        (user.getEmail() != null && user.getEmail().toLowerCase().contains(searchTerm.toLowerCase()))
                    )
                    .collect(Collectors.toList());
            }
            
            return users;
        } catch (Exception e) {
            logger.error("搜索用户时发生错误: {}", e.getMessage(), e);
            return new ArrayList<>();
        }
    }

    /**
     * 设置用户激活状态
     * @param userId 用户ID
     * @param status 激活状态
     * @return 操作结果
     */
    @Transactional
    public boolean setUserActiveStatus(Long userId, Boolean status) {
        try {
            Optional<User> userOpt = userRepository.findById(userId);
            if (userOpt.isPresent()) {
                User user = userOpt.get();
                String oldStatus = user.getIsActive() ? "启用" : "禁用";
                String newStatus = status ? "启用" : "禁用";
                
                user.setIsActive(status);
                userRepository.save(user);
                
                // 记录操作日志
                logService.logUserOperation(
                    userId, 
                    "STATUS_CHANGE", 
                    "用户状态变更", 
                    String.format("用户 %s 状态从 %s 变更为 %s", user.getUsername(), oldStatus, newStatus)
                );
                
                // 如果禁用用户，撤销其所有Token
                if (!status) {
                    tokenBlacklistService.revokeUserTokens(userId);
                    logService.logUserOperation(userId, "TOKEN_REVOKE", "撤销Token", "用户被禁用，撤销所有Token");
                }
                
                logger.info("用户状态已更新: userId={}, username={}, status={}", userId, user.getUsername(), status);
                return true;
            }
            logger.warn("尝试更新不存在的用户状态: userId={}", userId);
            return false;
        } catch (Exception e) {
            logger.error("设置用户状态时发生错误: userId={}, status={}, error={}", userId, status, e.getMessage(), e);
            return false;
        }
    }

    /**
     * 重置用户密码
     * @param userId 用户ID
     * @return 新密码（明文）
     */
    @Transactional
    public String resetPassword(Long userId) {
        try {
            Optional<User> userOpt = userRepository.findById(userId);
            if (userOpt.isPresent()) {
                User user = userOpt.get();
                
                // 生成新的随机密码
                String newPassword = generateRandomPassword();
                user.setPassword(passwordEncoder.encode(newPassword));
                userRepository.save(user);
                
                // 记录操作日志
                logService.logUserOperation(
                    userId, 
                    "PASSWORD_RESET", 
                    "密码重置", 
                    String.format("管理员重置用户 %s 的密码", user.getUsername())
                );
                
                // 撤销用户所有Token，强制重新登录
                tokenBlacklistService.revokeUserTokens(userId);
                logService.logUserOperation(userId, "TOKEN_REVOKE", "撤销Token", "密码重置后撤销所有Token");
                
                logger.info("用户密码已重置: userId={}, username={}", userId, user.getUsername());
                return newPassword;
            }
            logger.warn("尝试重置不存在用户的密码: userId={}", userId);
            return null;
        } catch (Exception e) {
            logger.error("重置用户密码时发生错误: userId={}, error={}", userId, e.getMessage(), e);
            return null;
        }
    }

    /**
     * 删除用户
     * @param userId 用户ID
     * @return 操作结果
     */
    @Transactional
    public boolean deleteUser(Long userId) {
        try {
            Optional<User> userOpt = userRepository.findById(userId);
            if (userOpt.isPresent()) {
                User user = userOpt.get();
                
                // 检查是否为管理员
                if (user.isAdmin()) {
                    logger.warn("尝试删除管理员用户: userId={}, username={}", userId, user.getUsername());
                    logService.logUserOperation(userId, "DELETE_FAILED", "删除用户失败", "尝试删除管理员用户被拒绝");
                    return false;
                }
                
                // 记录操作日志
                logService.logUserOperation(
                    userId, 
                    "USER_DELETE", 
                    "删除用户", 
                    String.format("管理员删除用户 %s", user.getUsername())
                );
                
                // 撤销用户所有Token
                tokenBlacklistService.revokeUserTokens(userId);
                
                // 删除用户
                userRepository.delete(user);
                
                logger.info("用户已删除: userId={}, username={}", userId, user.getUsername());
                return true;
            }
            logger.warn("尝试删除不存在的用户: userId={}", userId);
            return false;
        } catch (Exception e) {
            logger.error("删除用户时发生错误: userId={}, error={}", userId, e.getMessage(), e);
            return false;
        }
    }

    /**
     * 获取用户最近活动记录
     * @param userId 用户ID
     * @return 活动记录列表
     */
    public List<Map<String, Object>> getUserRecentActivities(Long userId) {
        try {
            List<Map<String, Object>> activities = new ArrayList<>();
            
            // 从LogService获取实际的用户操作日志
            List<UserOperationLog> userLogs = logService.getUserOperationLogs(userId, 10);
            for (UserOperationLog log : userLogs) {
                Map<String, Object> activity = new HashMap<>();
                activity.put("operation", log.getOperation());
                activity.put("operationTime", log.getOperationTime());
                activity.put("operationDetails", log.getOperationDetails());
                activity.put("operationType", log.getOperationType());
                activities.add(activity);
            }
            
            // 如果没有日志记录，添加基本的用户信息作为默认活动
            if (activities.isEmpty()) {
                Optional<User> userOpt = userRepository.findById(userId);
                if (userOpt.isPresent()) {
                    User user = userOpt.get();
                    
                    Map<String, Object> activity = new HashMap<>();
                    activity.put("operation", "用户注册");
                    activity.put("operationTime", user.getCreatedAt());
                    activity.put("operationDetails", "用户账户创建");
                    activity.put("operationType", "REGISTER");
                    activities.add(activity);
                }
            }
            
            return activities;
        } catch (Exception e) {
            logger.error("获取用户活动记录时发生错误: userId={}, error={}", userId, e.getMessage(), e);
            return new ArrayList<>();
        }
    }

    /**
     * 更新用户邮箱
     * @param userId 用户ID
     * @param newEmail 新邮箱
     * @return 操作结果
     */
    @Transactional
    public boolean updateUserEmail(Long userId, String newEmail) {
        try {
            // 检查新邮箱是否已被其他用户使用
            if (newEmail != null && userRepository.existsByEmail(newEmail)) {
                Optional<User> existingUser = userRepository.findByEmail(newEmail);
                if (existingUser.isPresent() && !existingUser.get().getUserId().equals(userId)) {
                    logger.warn("更新邮箱失败 - 邮箱已被其他用户使用: {}", newEmail);
                    return false;
                }
            }

            Optional<User> userOpt = userRepository.findById(userId);
            if (userOpt.isPresent()) {
                User user = userOpt.get();
                String oldEmail = user.getEmail();
                user.setEmail(newEmail);
                userRepository.save(user);
                
                // 记录操作日志
                logService.logUserOperation(
                    userId, 
                    "EMAIL_UPDATE", 
                    "更新邮箱", 
                    String.format("用户 %s 邮箱从 %s 更新为 %s", user.getUsername(), oldEmail, newEmail)
                );
                
                logger.info("用户邮箱已更新: userId={}, username={}, oldEmail={}, newEmail={}", 
                    userId, user.getUsername(), oldEmail, newEmail);
                return true;
            }
            logger.warn("尝试更新不存在用户的邮箱: userId={}", userId);
            return false;
        } catch (Exception e) {
            logger.error("更新用户邮箱时发生错误: userId={}, newEmail={}, error={}", userId, newEmail, e.getMessage(), e);
            return false;
        }
    }

    /**
     * 验证用户密码
     * @param userId 用户ID
     * @param password 要验证的密码
     * @return 验证结果
     */
    public boolean verifyPassword(Long userId, String password) {
        try {
            Optional<User> userOpt = userRepository.findById(userId);
            if (userOpt.isPresent()) {
                User user = userOpt.get();
                boolean isValid = passwordEncoder.matches(password, user.getPassword());
                
                // 记录密码验证日志（不记录具体密码内容）
                logService.logUserOperation(
                    userId, 
                    "PASSWORD_VERIFY", 
                    "密码验证", 
                    String.format("用户 %s 密码验证%s", user.getUsername(), isValid ? "成功" : "失败")
                );
                
                logger.info("用户密码验证: userId={}, username={}, result={}", userId, user.getUsername(), isValid);
                return isValid;
            }
            logger.warn("尝试验证不存在用户的密码: userId={}", userId);
            return false;
        } catch (Exception e) {
            logger.error("验证用户密码时发生错误: userId={}, error={}", userId, e.getMessage(), e);
            return false;
        }
    }

    /**
     * 修改用户密码
     * @param userId 用户ID
     * @param oldPassword 旧密码
     * @param newPassword 新密码
     * @return 操作结果
     */
    @Transactional
    public boolean changePassword(Long userId, String oldPassword, String newPassword) {
        try {
            Optional<User> userOpt = userRepository.findById(userId);
            if (userOpt.isPresent()) {
                User user = userOpt.get();
                
                // 验证旧密码
                if (!passwordEncoder.matches(oldPassword, user.getPassword())) {
                    logger.warn("修改密码失败 - 旧密码错误: userId={}, username={}", userId, user.getUsername());
                    logService.logUserOperation(
                        userId, 
                        "PASSWORD_CHANGE_FAILED", 
                        "修改密码失败", 
                        String.format("用户 %s 修改密码失败 - 旧密码错误", user.getUsername())
                    );
                    return false;
                }
                
                // 检查新密码与旧密码是否相同
                if (passwordEncoder.matches(newPassword, user.getPassword())) {
                    logger.warn("修改密码失败 - 新密码与旧密码相同: userId={}, username={}", userId, user.getUsername());
                    logService.logUserOperation(
                        userId, 
                        "PASSWORD_CHANGE_FAILED", 
                        "修改密码失败", 
                        String.format("用户 %s 修改密码失败 - 新密码与旧密码相同", user.getUsername())
                    );
                    return false;
                }
                
                // 更新密码
                user.setPassword(passwordEncoder.encode(newPassword));
                userRepository.save(user);
                
                // 记录操作日志
                logService.logUserOperation(
                    userId, 
                    "PASSWORD_CHANGE", 
                    "修改密码", 
                    String.format("用户 %s 成功修改密码", user.getUsername())
                );
                
                // 撤销用户所有Token，强制重新登录
                tokenBlacklistService.revokeUserTokens(userId);
                logService.logUserOperation(userId, "TOKEN_REVOKE", "撤销Token", "密码修改后撤销所有Token");
                
                logger.info("用户密码已修改: userId={}, username={}", userId, user.getUsername());
                return true;
            }
            logger.warn("尝试修改不存在用户的密码: userId={}", userId);
            return false;
        } catch (Exception e) {
            logger.error("修改用户密码时发生错误: userId={}, error={}", userId, e.getMessage(), e);
            return false;
        }
    }

    /**
     * 生成随机密码
     * @return 随机密码
     */
    private String generateRandomPassword() {
        String chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        StringBuilder password = new StringBuilder();
        
        for (int i = 0; i < 8; i++) {
            int index = (int) (Math.random() * chars.length());
            password.append(chars.charAt(index));
        }
        
        return password.toString();
    }

    /**
     * 用户统计信息类
     */
    public static class UserStats {
        private final long totalUsers;
        private final long activeUsers;
        private final long inactiveUsers;

        public UserStats(long totalUsers, long activeUsers, long inactiveUsers) {
            this.totalUsers = totalUsers;
            this.activeUsers = activeUsers;
            this.inactiveUsers = inactiveUsers;
        }

        public long getTotalUsers() { return totalUsers; }
        public long getActiveUsers() { return activeUsers; }
        public long getInactiveUsers() { return inactiveUsers; }
    }
}